using System;
using System.Collections.Generic;
using System.Text;

namespace Mud.EmlenMudMain.Modules
{
  public interface IEmlenMudAction
  {
    //ModuleResponse AllowAction(ActionParameters actionParams);
    //ModuleResponse PerformAction(ActionParameters actionParams);
    //List<Guid> ActionDependencies(ActionParameters actionParams);
    //int DesiredActionAllowPriority(ActionParameters actionParams);
    //int DesiredActionPerformPriority(ActionParameters actionParams);
    //Guid GetActionGuid();
    //string GetActionFriendlyName();
    //string GetActionFriendlyDescription();
  }

  /// <summary>
  /// Functions that begin with "Do" means the MUD is
  /// telling the module to do something.  A "Get"
  /// prefix means the module is being queried and 
  /// needs to return an answer... A "Set" prefix means
  /// the module needs to store some information,
  /// such as an event to raise or a callback to
  /// perform at a future time.
  /// </summary>
  //public interface IEmlenMudModuleInterface
  //{
  //  /// <summary>
  //  /// This function will be called when the module is first loaded.
  //  /// This takes the place of a constructor when dynamically loading
  //  /// a module...
  //  /// </summary>
  //  /// <param name="EmlenMud"></param>
  //  /// <returns></returns>
  //  ModuleResponse InitializeModule();

  //  /// <summary>
  //  /// Responsible for handling the action (and also checking if
  //  /// the action is allowed)
  //  /// </summary>
  //  /// <param name="inParam"></param>
  //  /// <param name="actionType"></param>
  //  /// <param name="szMessage"></param>
  //  /// <returns></returns>
  //  ModuleResponse DoHandleAction(ActionParameters inParam, ActionTypes actionType, out string szMessage);

  //  /// <summary>
  //  /// If this module is dependent on other modules being loaded first
  //  /// (for instance, some item types and enums might be added by 
  //  /// another module), then this list should contain the guids of
  //  /// those modules.
  //  /// </summary>
  //  /// <param name="EmlenMud"></param>
  //  /// <param name="actionType"></param>
  //  /// <returns></returns>
  //  List<Guid> GetModuleDependencies(IEmlenMud EmlenMud, ActionTypes actionType);

  //  /// <summary>
  //  /// The desired priority - 0 indicates that the action should be
  //  /// executed whenever... regular MUD commands have priority
  //  /// of 1000, so if you want to completely block out a function,
  //  /// you should set your action to a priority greater than 1000
  //  /// </summary>
  //  /// <param name="ModulesThatHaveAlreadyExecutedAction"></param>
  //  /// <param name="EmlenMud"></param>
  //  /// <param name="actionType"></param>
  //  /// <returns></returns>
  //  int GetDesiredPriority(List<Guid> ModulesThatHaveAlreadyExecutedAction, ActionTypes actionType);

  //  /// <summary>
  //  /// Is handling of the action thread-safe? Can we do it in the background
  //  /// without locking anything?
  //  /// </summary>
  //  /// <param name="EmlenMud"></param>
  //  /// <param name="actionType"></param>
  //  /// <returns></returns>
  //  bool GetIsHandleActionThreadSafe(IEmlenMud EmlenMud, ActionTypes actionType);

  //  /// <summary>
  //  /// For each action type, a module can implement multiple actions
  //  /// </summary>
  //  /// <param name="EmlenMud"></param>
  //  /// <returns></returns>
  //  Dictionary<ActionTypes, List<IEmlenMudAction>> GetHandledActions();

  //  /// <summary>
  //  /// This returns a list of actions the module is interested in executing
  //  /// when a certain ActionsAndBehavior GeneralTypeOfEffect occurs.
  //  /// </summary>
  //  /// <param name="EmlenMud"></param>
  //  /// <param name="actionType">The action type</param>
  //  /// <returns>A list of Actions to take when the action type occurs</returns>
  //  List<IEmlenMudAction> GetHandledActions(IEmlenMud EmlenMud, ActionTypes actionType);

  //  /// <summary>
  //  /// The MUD instance will tell the module what event
  //  /// handler it wants called when a hook is
  //  /// done executing
  //  /// </summary>
  //  /// <param name="EmlenMud"></param>
  //  /// <param name="eventHandler">This is a delegate 
  //  /// (function pointer, basically) for the event handler 
  //  /// that should be called when the module's hook completes</param>
  //  /// <returns>Can the module support raising events when
  //  /// the save has completed?</returns>
  //  ModuleResponse SetAsyncActionCallback(IEmlenMud EmlenMud, EventHandler<ModuleEventArgType> eventHandler, ActionTypes actionType);

  //  /// <summary>
  //  /// Each module must have its own GUID (unique ID)
  //  /// This enables module dependencies, etc
  //  /// </summary>
  //  /// <returns>Returns the model's GUID</returns>
  //  Guid GetModuleID();

  //  /// <summary>
  //  /// A friendly name for the module
  //  /// </summary>
  //  /// <param name="EmlenMud"></param>
  //  /// <returns></returns>
  //  string GetModuleFriendlyName();

  //  /// <summary>
  //  /// Retrieves a description of the module
  //  /// </summary>
  //  /// <param name="EmlenMud"></param>
  //  /// <returns></returns>
  //  string GetModuleDescription();
  //}

}
